The following content has been provided by the University of Erlangen-Nürnberg.

Thank you very much for the invitation. I am very happy to be here and to be able to talk about my work.

So I think I will switch my talk to English. Hi.

And I would also like to keep the seminar interactive, so if you have any questions on the way, please feel free to ask.

So what I will talk here today is about a European project that is coordinated by my group, which deals with how can we improve programmability

and performance portability for this new heterogeneous medical systems.

And so that's it. Yeah. Before I go into the talk, I will give you a brief overview of our background.

So we have been traditionally working on barrel computing, high-performance computing, so this goes back to the 90s, to the early 90s.

So in particular, in programming models and languages, compilers, random technologies, programming environment and tools.

So maybe some of you have heard high-performance Fortran, which has been developed in the mid-90s, which has not been a big success,

but which has made a lot of contributions to the automatic realization or semi-automatic realization for numerical codes and so on.

Yeah, and now with the renaissance of barrel computing, I would say, with all these multi-core developments,

we are very strong focusing again on this barrel computing issues.

We have also activities in grid computing, cloud computing, service-oriented architectures,

where we also try to look at how can we make those distributed infrastructures, which are, by the way, also heterogeneous, but on a large scale,

how can we make such infrastructures available for domain scientists in scientific computing.

So here the topics are a little bit different. So, for example, how can you provide an application that is running on a glass,

there's a service over the grid, over the cloud, on-demand supercomputing and also data management, big data, which is very important also for the future.

So over the last years, we have been very active in European projects in particular,

and my talk will focus here on this PEPA project, which is a three-year project, which is now in its final year.

And we have one project that deals with similar issues, automatic performance tuning for barrel architectures,

which has just started and which is organized by Michael Gern from TU München, where we also participate as a partner.

So, a brief outline for my talk. I will give a brief motivation on heterogeneous many ecosystems,

but I think I don't have to motivate very much here at this group.

But then try to briefly explain the overall idea of PEPA and the approach PEPA is pursuing,

and then pick up a few topics where my group is in particular involved in.

So, first we have developed a basic coordination language, so overall PEPA pursues a compositional approach to barrel programming,

where you compose a program of components and you have a coordination language to describe this composition.

Then we have a transformation system developed, which translates high-level programs, component-based programs,

into a representation that utilizes the underlying runtime system, and I will present a few results.

Currently we are entering the phase of evaluation, so we do not have too many results at the moment,

but we hope to have more in the near future.

So, heterogeneous many co-architectures, there's a clear trend towards heterogeneous many co-architectures,

mainly because those architectures promise a better power-performance ratio.

So, heterogeneous architecture usually consists of different types, of course,

but you could also see a homogeneous architecture could become heterogeneous if you have, for example,

for different domains, different clock frequencies and so on.

So, there are different types of heterogeneity, yeah, but so usually you have different core types,

where some core types are specialized for different tasks, application domains,

and now you not only have to parallelize your code, but you also have to partition your code,

you have to decide which parts of your code run on which core types,

and so that's what we call here specialization.

And to some extent, such heterogeneous architectures allow you to mitigate Amdahl's Law,

so if you have a serial part in your code and you have a special ASIC,

a special purpose processor for speeding up the serial code, then you can achieve much better scalability overall.

So, examples, yeah, you know the cell processor, a very interesting research project,

the European research project was the Shark project,

they developed a generic heterogeneous architecture with different types, of course,

so this is here, for example, specialized to biomedical applications or to image processing or to encoding and so on.

So, there's a lot of information available on the web.